package com.example.aidocengine.processor;

import com.example.aidocengine.common.constant.BusinessConstant;
import com.example.aidocengine.common.exception.BusinessException;
import com.example.aidocengine.common.result.ResultCode;
import com.example.aidocengine.common.utils.ValidationUtils;
import com.example.aidocengine.pojo.entity.CommandingUnit;
import com.example.aidocengine.pojo.entity.DeviceInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.stereotype.Component;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 合并单元格信息存储类
 */
class MergedCellInfo {
    public String stationName;
    public String voltageLevel; 
    public String deviceName;
    
    public MergedCellInfo(String stationName, String voltageLevel, String deviceName) {
        this.stationName = stationName;
        this.voltageLevel = voltageLevel;
        this.deviceName = deviceName;
    }
}

@Slf4j
@Component
public class ExcelProcessor {

    /**
     * 解析设备模板Excel文件
     *
     * @param file 上传的Excel文件，包含设备模板数据
     * @return 包含解析结果的Map对象，key包括commandingUnits（受令单位列表）、
     *         deviceInfos（设备信息列表）和totalRecords（总记录数）
     * @throws BusinessException 当文件解析失败时抛出业务异常
     */
    public Map<String, Object> parseDeviceTemplateExcel(MultipartFile file) {
        Map<String, Object> result = new HashMap<>();
        List<CommandingUnit> commandingUnits = new ArrayList<>();
        List<DeviceInfo> deviceInfos = new ArrayList<>();
        
        try (Workbook workbook = new XSSFWorkbook(file.getInputStream())) {
            // 解析受令单位工作表
            Sheet commandingUnitSheet = workbook.getSheet("受令单位");
            if (commandingUnitSheet != null) {
                commandingUnits = parseCommandingUnitSheet(commandingUnitSheet);
                log.info("解析受令单位数据，共{}条", commandingUnits.size());
            }

            // 解析设备信息工作表
            String[] deviceSheetNames = {"线路", "主变", "母线及附属设备", "补充"};
            String[] deviceCategories = {
                BusinessConstant.DEVICE_CATEGORY_LINE,
                BusinessConstant.DEVICE_CATEGORY_TRANSFORMER,
                BusinessConstant.DEVICE_CATEGORY_BUS,
                BusinessConstant.DEVICE_CATEGORY_SUPPLEMENT
            };

            for (int i = 0; i < deviceSheetNames.length; i++) {
                Sheet deviceSheet = workbook.getSheet(deviceSheetNames[i]);
                if (deviceSheet != null) {
                    List<DeviceInfo> categoryDevices = parseDeviceSheet(deviceSheet, deviceCategories[i]);
                    deviceInfos.addAll(categoryDevices);
                    log.info("解析{}设备数据，共{}条", deviceSheetNames[i], categoryDevices.size());
                }
            }

            result.put("commandingUnits", commandingUnits);
            result.put("deviceInfos", deviceInfos);
            result.put("totalRecords", commandingUnits.size() + deviceInfos.size());
            
        } catch (IOException e) {
            log.error("解析Excel文件失败：", e);
            throw new BusinessException(ResultCode.DOCUMENT_PARSE_ERROR);
        }

        return result;
    }

    /**
     * 解析受令单位工作表，从Excel的Sheet中提取受令单位信息并封装为CommandingUnit对象列表。
     *
     * @param sheet Excel中的工作表对象（这里只能是受令单位表sheet，包含受令单位数据）
     * @return 解析后的受令单位列表，每个元素为CommandingUnit对象
     */
    private List<CommandingUnit> parseCommandingUnitSheet(Sheet sheet) {
        List<CommandingUnit> commandingUnits = new ArrayList<>();
        
        if (sheet.getLastRowNum() < 1) {
            log.warn("受令单位工作表无数据行");
            return commandingUnits;
        }
        
        // 先检查工作表结构
        log.info("🔍 受令单位工作表名称：{}", sheet.getSheetName());
        log.info("🔍 总行数：{}", sheet.getLastRowNum() + 1);
        
        // 检查标题行
        Row headerRow = sheet.getRow(0);
        if (headerRow != null) {
            log.info("🔍 标题行列数：{}", headerRow.getLastCellNum());
            for (int i = 0; i < headerRow.getLastCellNum(); i++) {
                Cell cell = headerRow.getCell(i);
                String headerValue = getCellValueAsString(cell);
                log.info("🔍 标题行第{}列（{}列）：'{}'", i, (char)('A' + i), headerValue);
            }
        }
        
        // 动态查找受令单位列
        int unitNameColumnIndex = -1;
        
        // 尝试查找包含"受令单位"相关文字的列，优先精确匹配
        String[] possibleHeaders = {"本启动涉及的受令单位", "受令单位", "单位名称", "单位"};
        for (String header : possibleHeaders) {
            unitNameColumnIndex = findColumnIndex(headerRow, header);
            if (unitNameColumnIndex != -1) {
                log.info("🔍 找到受令单位列：{} 位于第{}列", header, unitNameColumnIndex);
                break;
            }
        }
        
        if (unitNameColumnIndex == -1) {
            log.warn("❌ 未找到受令单位列，使用默认第5列（F列）");
            unitNameColumnIndex = 5; // 默认使用F列
        }
        
        // 从第二行开始读取数据（第一行是标题）
        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            // 跳过空行
            if (row == null) continue;
            
            try {
                CommandingUnit unit = new CommandingUnit();
                
                // 读取受令单位名称（使用刚才找到的目标列，现在正在行循环）
                Cell unitNameCell = row.getCell(unitNameColumnIndex);
                log.info("🔍 调试：第{}行，第{}列单元格存在={}", i + 1, unitNameColumnIndex, unitNameCell != null);
                if (unitNameCell != null) {
                    String unitName = getCellValueAsString(unitNameCell);
                    log.info("🔍 第{}行受令单位原始数据（第{}列）：'{}'", i + 1, unitNameColumnIndex, unitName);
                    
                    // 详细验证过程
                    boolean isValid = isValidUnitName(unitName);
                    log.info("🔍 验证结果：{} -> {}", unitName, isValid ? "有效" : "无效");
                    
                    if (isValid) {
                        unit.setUnitName(unitName.trim());
                        unit.setStatus(1);
                        unit.setCreatedTime(LocalDateTime.now());
                        unit.setUpdatedTime(LocalDateTime.now());
                        commandingUnits.add(unit);
                        log.info("✅ 成功解析受令单位：{}", unitName.trim());
                    } else {
                        log.warn("❌ 跳过无效受令单位：{}", unitName);
                    }
                } else {
                    log.info("🔍 第{}行第{}列单元格为空", i + 1, unitNameColumnIndex);
                    
                    // 检查该行的所有非空列，帮助定位数据位置
                    log.info("🔍 第{}行所有非空数据：", i + 1);
                    for (int j = 0; j < row.getLastCellNum(); j++) {
                        Cell cell = row.getCell(j);
                        if (cell != null) {
                            String cellValue = getCellValueAsString(cell);
                            if (cellValue != null && !cellValue.trim().isEmpty()) {
                                log.info("🔍   第{}列（{}列）：'{}'", j, (char)('A' + j), cellValue);
                            }
                        }
                    }
                }
            } catch (Exception e) {
                log.warn("解析受令单位第{}行失败：{}", i + 1, e.getMessage());
            }
        }
        
        return commandingUnits;
    }

    /**
     * 解析设备信息工作表
     */
    /**
     * 解析设备信息工作表 - 严格按Excel结构和CONCATENATE公式处理
     */
    private List<DeviceInfo> parseDeviceSheet(Sheet sheet, String deviceCategory) {
        List<DeviceInfo> deviceInfos = new ArrayList<>();
        
        if (sheet.getLastRowNum() < 1) {
            log.warn("{}设备工作表无数据行", deviceCategory);
            return deviceInfos;
        }
        
        log.info("开始解析{}设备表，共{}行数据", deviceCategory, sheet.getLastRowNum());
        
        // 根据Excel模板结构读取数据，动态查找列索引
        Row headerRow = sheet.getRow(0);
        int stationNameCol = findColumnIndex(headerRow, "厂站");
        int voltageLevelCol = findColumnIndex(headerRow, "电压等级");
        int deviceNameCol = findColumnIndex(headerRow, "设备名称");
        int deviceCodeCol = findColumnIndex(headerRow, "设备编号");
        int deviceTypeCol = findColumnIndex(headerRow, "设备类型");
        int deviceDoubleCodeCol = findColumnIndex(headerRow, "设备双编");
        
        log.info("📊 列索引映射: 厂站={}, 电压等级={}, 设备名称={}, 设备编号={}, 设备类型={}, 设备双编={}", 
                 stationNameCol, voltageLevelCol, deviceNameCol, deviceCodeCol, deviceTypeCol, deviceDoubleCodeCol);
        
        // 分析合并单元格区域，建立行级别的映射
        Map<Integer, MergedCellInfo> mergedCellMap = analyzeMergedRegions(sheet, stationNameCol, voltageLevelCol, deviceNameCol);
        
        // 从第二行开始读取数据（第一行是标题）
        for (int i = 1; i <= sheet.getLastRowNum(); i++) {
            Row row = sheet.getRow(i);
            if (row == null) continue;
            
            try {
                DeviceInfo device = parseDeviceRow(row, i, deviceCategory, mergedCellMap, 
                    stationNameCol, voltageLevelCol, deviceNameCol, deviceCodeCol, deviceTypeCol, deviceDoubleCodeCol);
                
                if (device != null && isValidDeviceData(device)) {
                    deviceInfos.add(device);
                    log.info("✓ 解析设备成功：第{}行 - {} - {}", i + 1, device.getStationName(), device.getDeviceDoubleCode());
                } else if (device != null) {
                    log.warn("✗ 跳过无效设备：第{}行 - {} - {}", i + 1, 
                            device.getStationName(), device.getDeviceDoubleCode());
                }
                
            } catch (Exception e) {
                log.warn("解析{}设备第{}行失败：{}", deviceCategory, i + 1, e.getMessage(), e);
            }
        }
        
        log.info("{}设备解析完成：{}条记录", deviceCategory, deviceInfos.size());
        return deviceInfos;
    }
    
    /**
     * 解析单行设备数据 - 严格按CONCATENATE公式生成设备双编
     */
    private DeviceInfo parseDeviceRow(Row row, int rowIndex, String deviceCategory, 
                                     Map<Integer, MergedCellInfo> mergedCellMap,
                                     int stationNameCol, int voltageLevelCol, int deviceNameCol, 
                                     int deviceCodeCol, int deviceTypeCol, int deviceDoubleCodeCol) {
        
        DeviceInfo device = new DeviceInfo();
        
        // 获取合并单元格信息（厂站名称、电压等级、设备名称）
        MergedCellInfo mergedInfo = mergedCellMap.get(rowIndex);
        if (mergedInfo != null) {
            device.setStationName(mergedInfo.stationName);
            device.setVoltageLevel(mergedInfo.voltageLevel);
            device.setDeviceName(mergedInfo.deviceName);
        } else {
            // 直接读取单元格值（非合并单元格）
            device.setStationName(getDirectCellValue(row.getCell(stationNameCol)));
            device.setVoltageLevel(getDirectCellValue(row.getCell(voltageLevelCol)));
            device.setDeviceName(getDirectCellValue(row.getCell(deviceNameCol)));
        }
        
        // 读取独立单元格数据（设备编号、设备类型）
        String deviceCode = getDirectCellValue(row.getCell(deviceCodeCol));
        String deviceType = getDirectCellValue(row.getCell(deviceTypeCol));
        
        device.setDeviceCode(deviceCode);
        device.setDeviceType(deviceType);
        
        // 设备双编处理 - 严格按CONCATENATE公式：=CONCATENATE($B$2,$C$2,D2,E2)
        String excelDeviceDoubleCode = getDirectCellValue(row.getCell(deviceDoubleCodeCol));
        if (ValidationUtils.isNotEmpty(excelDeviceDoubleCode)) {
            // 使用Excel中的设备双编
            device.setDeviceDoubleCode(excelDeviceDoubleCode.trim());
        } else {
            // 按CONCATENATE公式生成：电压等级+设备名称+设备编号+设备类型
            String generatedDoubleCode = generateDeviceDoubleCode(
                device.getVoltageLevel(), device.getDeviceName(), deviceCode, deviceType);
            device.setDeviceDoubleCode(generatedDoubleCode);
            log.debug("按CONCATENATE公式生成设备双编：'{}'", generatedDoubleCode);
        }
        
        // 早期检查：如果设备双编为空且设备编号为空，直接跳过这一行
        if (!ValidationUtils.isNotEmpty(device.getDeviceDoubleCode()) && 
            !ValidationUtils.isNotEmpty(deviceCode)) {
            log.debug("第{}行缺少设备编号，跳过处理", rowIndex + 1);
            return null;
        }
        
        // 设置其他字段
        device.setDeviceCategory(deviceCategory);
        device.setExcelRowNumber(rowIndex + 1);
        device.setExcelSheetName(deviceCategory);
        device.setStatus(1);
        device.setCreatedTime(LocalDateTime.now());
        device.setUpdatedTime(LocalDateTime.now());
        
        // 主变设备特殊处理
        if ("主变".equals(deviceCategory)) {
            processTransformerDevice(device, deviceType);
        }
        
        log.debug("第{}行解析结果：厂站='{}', 电压等级='{}', 设备名称='{}', 设备编号='{}', 设备类型='{}', 设备双编='{}'",
                rowIndex + 1, device.getStationName(), device.getVoltageLevel(), 
                device.getDeviceName(), device.getDeviceCode(), device.getDeviceType(), device.getDeviceDoubleCode());
        
        return device;
    }
    
    /**
     * 分析合并单元格区域，为每行建立映射
     */
    private Map<Integer, MergedCellInfo> analyzeMergedRegions(Sheet sheet, int stationNameCol, int voltageLevelCol, int deviceNameCol) {
        Map<Integer, MergedCellInfo> mergedCellMap = new HashMap<>();
        
        log.info("🔍 开始分析合并单元格区域，总合并区域数：{}", sheet.getNumMergedRegions());
        
        // 遍历所有合并区域
        for (int i = 0; i < sheet.getNumMergedRegions(); i++) {
            CellRangeAddress mergedRegion = sheet.getMergedRegion(i);
            
            // 获取合并区域的第一个单元格的值
            Row firstRow = sheet.getRow(mergedRegion.getFirstRow());
            if (firstRow == null) continue;
            
            String stationName = null;
            String voltageLevel = null;
            String deviceName = null;
            
            // 根据列索引判断是哪种合并单元格
            int col = mergedRegion.getFirstColumn();
            log.info("🔍 合并区域{}：行{}-{}，列{}-{}，首列索引={}", 
                    i, mergedRegion.getFirstRow(), mergedRegion.getLastRow(),
                    mergedRegion.getFirstColumn(), mergedRegion.getLastColumn(), col);
            
            if (col == stationNameCol) {
                stationName = getDirectCellValue(firstRow.getCell(col));
                log.info("🏭 提取厂站名称：'{}'", stationName);
            } else if (col == voltageLevelCol) {
                voltageLevel = getDirectCellValue(firstRow.getCell(col));
                log.info("⚡ 提取电压等级：'{}'", voltageLevel);
            } else if (col == deviceNameCol) {
                deviceName = getDirectCellValue(firstRow.getCell(col));
                log.info("🔧 提取设备名称：'{}'", deviceName);
            }
            
            // 为合并区域内的每一行建立映射
            for (int rowIdx = mergedRegion.getFirstRow(); rowIdx <= mergedRegion.getLastRow(); rowIdx++) {
                MergedCellInfo existingInfo = mergedCellMap.get(rowIdx);
                if (existingInfo == null) {
                    existingInfo = new MergedCellInfo(null, null, null);
                    mergedCellMap.put(rowIdx, existingInfo);
                }
                
                // 更新对应字段
                if (stationName != null) existingInfo.stationName = stationName;
                if (voltageLevel != null) existingInfo.voltageLevel = voltageLevel;
                if (deviceName != null) existingInfo.deviceName = deviceName;
            }
        }
        
        return mergedCellMap;
    }
    
    /**
     * 按CONCATENATE公式生成设备双编
     */
    private String generateDeviceDoubleCode(String voltageLevel, String deviceName, String deviceCode, String deviceType) {
        // 设备编号是必需的，没有设备编号就不生成设备双编
        if (!ValidationUtils.isNotEmpty(deviceCode)) {
            return "";
        }
        
        StringBuilder builder = new StringBuilder();
        
        if (ValidationUtils.isNotEmpty(voltageLevel)) {
            builder.append(voltageLevel.trim());
        }
        if (ValidationUtils.isNotEmpty(deviceName)) {
            builder.append(deviceName.trim());
        }
        if (ValidationUtils.isNotEmpty(deviceCode)) {
            builder.append(deviceCode.trim());
        }
        if (ValidationUtils.isNotEmpty(deviceType)) {
            builder.append(deviceType.trim());
        }
        
        return builder.toString();
    }
    
    /**
     * 处理主变设备的特殊逻辑
     */
    private void processTransformerDevice(DeviceInfo device, String deviceType) {
        // 主变设备的电压等级应该基于Excel中的实际电压等级列，而不是设备类型
        // 这里只设置变压器等级标识，电压等级保持从Excel读取的原始值
        
        String currentVoltageLevel = device.getVoltageLevel();
        
        if (ValidationUtils.isNotEmpty(deviceType)) {
            if (deviceType.contains("变高")) {
                device.setTransformerLevel("变高");
            } else if (deviceType.contains("变中")) {
                device.setTransformerLevel("变中");
            } else if (deviceType.contains("变低")) {
                device.setTransformerLevel("变低");
            } else if (deviceType.contains("本体")) {
                device.setTransformerLevel("本体");
            } else {
                // 根据电压等级推断变压器等级
                if ("220kV".equals(currentVoltageLevel)) {
                    device.setTransformerLevel("变高");
                } else if ("110kV".equals(currentVoltageLevel)) {
                    device.setTransformerLevel("变中");
                } else if ("10kV".equals(currentVoltageLevel)) {
                    device.setTransformerLevel("变低");
                }
            }
        } else {
            // 设备类型为空时，根据电压等级推断变压器等级
            if ("220kV".equals(currentVoltageLevel)) {
                device.setTransformerLevel("变高");
            } else if ("110kV".equals(currentVoltageLevel)) {
                device.setTransformerLevel("变中");
            } else if ("10kV".equals(currentVoltageLevel)) {
                device.setTransformerLevel("变低");
            }
        }
        
        log.debug("主变设备处理：设备类型='{}', 电压等级='{}', 变压器等级='{}'", 
                deviceType, device.getVoltageLevel(), device.getTransformerLevel());
    }

    /**
     * 获取单元格值并转为字符串，处理合并单元格
     */
    private String getCellValueAsString(Cell cell) {
        if (cell == null) {
            return "";
        }
        
        // 先尝试获取合并单元格的值
        String mergedValue = getMergedCellValue(cell);
        if (mergedValue != null && !mergedValue.trim().isEmpty()) {
            return mergedValue.trim();
        }
        
        // 如果不是合并单元格，直接获取单元格值
        return getDirectCellValue(cell);
    }
    
    /**
     * 查找列索引，根据列标题名称
     */
    private int findColumnIndex(Row headerRow, String columnName) {
        if (headerRow == null || columnName == null) {
            return -1;
        }
        
        log.info("🔍 查找列'{}'的索引", columnName);
        
        int bestMatch = -1;
        int shortestLength = Integer.MAX_VALUE;
        
        for (int i = 0; i < headerRow.getLastCellNum(); i++) {
            Cell cell = headerRow.getCell(i);
            if (cell != null) {
                String cellValue = getCellValueAsString(cell);
                log.info("🔍   第{}列内容：'{}'", i, cellValue);
                if (cellValue != null && cellValue.contains(columnName)) {
                    // 跳过"勿修改"列，优先选择数据列
                    if (cellValue.contains("勿修改")) {
                        log.info("🔍     跳过'勿修改'列：第{}列 - '{}'", i, cellValue);
                        continue;
                    }
                    // 如果找到匹配，选择内容最短的一个（更精确）
                    if (cellValue.length() < shortestLength) {
                        bestMatch = i;
                        shortestLength = cellValue.length();
                        log.info("🔍     找到更好的匹配：第{}列 - '{}'", i, cellValue);
                    }
                }
            }
        }
        
        log.info("🔍 列'{}'查找结果：索引={}", columnName, bestMatch);
        return bestMatch;
    }
    
    /**
     * 获取合并单元格的值
     */
    private String getMergedCellValue(Cell cell) {
        if (cell == null) {
            return null;
        }
        
        try {
            Sheet sheet = cell.getSheet();
            int rowIndex = cell.getRowIndex();
            int columnIndex = cell.getColumnIndex();
            
            // 检查当前单元格是否在合并区域内
            for (int i = 0; i < sheet.getNumMergedRegions(); i++) {
                try {
                    CellRangeAddress mergedRegion = sheet.getMergedRegion(i);
                    if (mergedRegion != null && mergedRegion.isInRange(rowIndex, columnIndex)) {
                        log.debug("单元格({}, {})在合并区域{}内：{}", rowIndex, columnIndex, i, mergedRegion.formatAsString());
                        // 获取合并区域的第一个单元格
                        Row firstRow = sheet.getRow(mergedRegion.getFirstRow());
                        if (firstRow != null) {
                            Cell firstCell = firstRow.getCell(mergedRegion.getFirstColumn());
                            if (firstCell != null) {
                                String value = getDirectCellValue(firstCell);
                                log.debug("从合并区域首单元格({}, {})获取值：'{}'", mergedRegion.getFirstRow(), mergedRegion.getFirstColumn(), value);
                                return value;
                            }
                        }
                    }
                } catch (Exception e) {
                    log.warn("处理第{}个合并区域时出现异常：{}", i, e.getMessage());
                    continue;
                }
            }
            
            // 如果不是合并单元格，直接返回单元格的值
            return getDirectCellValue(cell);
            
        } catch (Exception e) {
            log.warn("获取合并单元格值时出现异常，直接返回单元格值：{}", e.getMessage());
            return getDirectCellValue(cell);
        }
    }
    
    /**
     * 直接获取单元格值，不处理合并单元格
     */
    private String getDirectCellValue(Cell cell) {
        if (cell == null) {
            return "";
        }
        
        switch (cell.getCellType()) {
            case STRING:
                String value = cell.getStringCellValue();
                // 清理特殊字符和不可见字符
                if (value != null) {
                    value = value.trim()
                               .replace("\u0000", "")  // 清理null字符
                               .replace("\ufffd", "")  // 清理替换字符
                               .replaceAll("\\p{C}", ""); // 清理所有控制字符
                }
                return value;
            case NUMERIC:
                if (DateUtil.isCellDateFormatted(cell)) {
                    return cell.getDateCellValue().toString();
                } else {
                    double numericValue = cell.getNumericCellValue();
                    // 特殊处理电压等级数值，确保正确显示
                    if (numericValue == 10.0) {
                        return "10kV";
                    } else if (numericValue == 110.0) {
                        return "110kV";
                    } else if (numericValue == 220.0) {
                        return "220kV";
                    } else if (numericValue == Math.floor(numericValue)) {
                        return String.valueOf((long) numericValue);
                    } else {
                        return String.valueOf(numericValue);
                    }
                }
            case BOOLEAN:
                return String.valueOf(cell.getBooleanCellValue());
            case FORMULA:
                try {
                    switch (cell.getCachedFormulaResultType()) {
                        case STRING:
                            return cell.getStringCellValue();
                        case NUMERIC:
                            double numericValue = cell.getNumericCellValue();
                            // 特殊处理电压等级数值，确保正确显示
                            if (numericValue == 10.0) {
                                return "10kV";
                            } else if (numericValue == 110.0) {
                                return "110kV";
                            } else if (numericValue == 220.0) {
                                return "220kV";
                            } else if (numericValue == Math.floor(numericValue)) {
                                return String.valueOf((long) numericValue);
                            } else {
                                return String.valueOf(numericValue);
                            }
                        case BOOLEAN:
                            return String.valueOf(cell.getBooleanCellValue());
                        default:
                            return "";
                    }
                } catch (Exception e) {
                    log.warn("获取公式计算结果失败，返回公式文本：{}", cell.getCellFormula());
                    return cell.getCellFormula();
                }
            default:
                return "";
        }
    }
    
    /**
     * 验证设备数据是否有效
     */
    private boolean isValidDeviceData(DeviceInfo device) {
        // 检查必要字段 - 设备编号是关键字段
        if (!ValidationUtils.isNotEmpty(device.getDeviceDoubleCode()) || 
            !ValidationUtils.isNotEmpty(device.getStationName()) ||
            !ValidationUtils.isNotEmpty(device.getVoltageLevel()) ||
            !ValidationUtils.isNotEmpty(device.getDeviceCode())) {  // 设备编号必须存在
            return false;
        }
        
        // 过滤说明文字
        String stationName = device.getStationName();
        String deviceName = device.getDeviceName();
        String deviceDoubleCode = device.getDeviceDoubleCode();
        
        // 过滤包含说明文字的数据（但保留示例数据）
        String[] filterKeywords = {
            "填写说明", "请", "如需", "若存在", "复制", 
            "表格", "间隔", "多个", "空白", "一行", "仅", "设备导入填写", 
            "按实际情况", "相关说明", "请勿修改", "特殊命名", "公式", "直接补充"
        };
        
        // 特殊处理：如果厂站名称包含"示例"但同时有具体的设备双编，认为是有效示例数据
        boolean hasExampleButValid = stationName != null && stationName.contains("示例") && 
                                   ValidationUtils.isNotEmpty(deviceDoubleCode) && 
                                   !deviceDoubleCode.contains("示例") &&
                                   deviceDoubleCode.length() > 5; // 设备双编应该有一定长度
        
        if (!hasExampleButValid) {
            for (String keyword : filterKeywords) {
                if ((stationName != null && stationName.contains(keyword)) ||
                    (deviceName != null && deviceName.contains(keyword)) ||
                    (deviceDoubleCode != null && deviceDoubleCode.contains(keyword))) {
                    return false;
                }
            }
            
            // 额外过滤"填写"和"说明"，但如果是有效示例数据则不过滤
            if ((stationName != null && (stationName.contains("填写") || stationName.contains("说明"))) ||
                (deviceName != null && (deviceName.contains("填写") || deviceName.contains("说明"))) ||
                (deviceDoubleCode != null && (deviceDoubleCode.contains("填写") || deviceDoubleCode.contains("说明")))) {
                return false;
            }
        }
        
        // 检查设备双编是否为空或null字符串
        if ("null".equals(deviceDoubleCode) || deviceDoubleCode.trim().isEmpty()) {
            return false;
        }
        
        // 检查厂站名称长度是否异常（说明文字通常很长）
        if (stationName.length() > 50) {
            return false;
        }
        
        return true;
    }
    
    /**
     * 验证受令单位名称是否有效，过滤说明文字，过滤过长的文本，过滤纯数字（序号），过滤空文本
     */
    private boolean isValidUnitName(String unitName) {
        if (!ValidationUtils.isNotEmpty(unitName)) {
            return false;
        }
        
        unitName = unitName.trim();
        
        // 过滤明显的说明文字
        String[] filterKeywords = {
            "设备导入填写说明", "按实际情况", "填写", "说明", "表中", "涉及", "相关说明", 
            "请勿修改", "公式", "特殊命名", "直接补充", "空白处", "子表", "示例", "请", "如需", "若存在", "复制"
        };
        
        for (String keyword : filterKeywords) {
            if (unitName.contains(keyword)) {
                return false;
            }
        }
        
        // 过滤过长的文本（说明文字通常很长）
        if (unitName.length() > 50) {
            return false;
        }
        
        // 只过滤纯数字（序号），不过滤包含汉字的内容
        if (unitName.matches("^\\d+$")) {
            return false;
        }
        
        // 过滤空值和null字符串
        if ("null".equals(unitName) || unitName.trim().isEmpty()) {
            return false;
        }
        
        return true;
    }
}